"""
CRUD 操作

数据库的增删改查操作
"""

from sqlalchemy.orm import Session
from typing import Optional, List
import sys
from pathlib import Path

# 处理导入路径
if __name__ == "__main__" or "." not in __name__:
    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
    from stage2_advanced.chapter02_jwt import models, schemas
    from stage2_advanced.chapter02_jwt.security import hash_password
else:
    from . import models, schemas
    from .security import hash_password


# ========== 用户查询操作 ==========

def get_user(db: Session, user_id: int) -> Optional[models.User]:
    """
    根据 ID 获取用户
    
    Args:
        db: 数据库会话
        user_id: 用户 ID
        
    Returns:
        用户对象，如果不存在返回 None
    """
    return db.query(models.User).filter(models.User.id == user_id).first()


def get_user_by_username(db: Session, username: str) -> Optional[models.User]:
    """
    根据用户名获取用户
    
    Args:
        db: 数据库会话
        username: 用户名
        
    Returns:
        用户对象，如果不存在返回 None
    """
    return db.query(models.User).filter(models.User.username == username).first()


def get_user_by_email(db: Session, email: str) -> Optional[models.User]:
    """
    根据邮箱获取用户
    
    Args:
        db: 数据库会话
        email: 邮箱
        
    Returns:
        用户对象，如果不存在返回 None
    """
    return db.query(models.User).filter(models.User.email == email).first()


def get_users(db: Session, skip: int = 0, limit: int = 100) -> List[models.User]:
    """
    获取用户列表
    
    Args:
        db: 数据库会话
        skip: 跳过的记录数
        limit: 返回的最大记录数
        
    Returns:
        用户对象列表
    """
    return db.query(models.User).offset(skip).limit(limit).all()


# ========== 用户创建操作 ==========

def create_user(db: Session, user: schemas.UserCreate) -> models.User:
    """
    创建新用户
    
    Args:
        db: 数据库会话
        user: 用户创建数据
        
    Returns:
        创建的用户对象
    """
    # 加密密码
    hashed_password = hash_password(user.password)
    
    # 创建用户对象
    db_user = models.User(
        username=user.username,
        email=user.email,
        hashed_password=hashed_password,
        full_name=user.full_name,
        is_active=True,
        is_superuser=False
    )
    
    # 保存到数据库
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    
    return db_user


def create_superuser(
    db: Session,
    username: str,
    email: str,
    password: str,
    full_name: Optional[str] = None
) -> models.User:
    """
    创建超级用户（管理员）
    
    Args:
        db: 数据库会话
        username: 用户名
        email: 邮箱
        password: 密码
        full_name: 全名
        
    Returns:
        创建的超级用户对象
    """
    hashed_password = hash_password(password)
    
    db_user = models.User(
        username=username,
        email=email,
        hashed_password=hashed_password,
        full_name=full_name,
        is_active=True,
        is_superuser=True  # 设置为超级用户
    )
    
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    
    return db_user


# ========== 用户更新操作 ==========

def update_user(
    db: Session,
    user: models.User,
    user_update: schemas.UserUpdate
) -> models.User:
    """
    更新用户信息
    
    Args:
        db: 数据库会话
        user: 要更新的用户对象
        user_update: 更新数据
        
    Returns:
        更新后的用户对象
    """
    # 只更新提供的字段
    update_data = user_update.model_dump(exclude_unset=True)
    
    for field, value in update_data.items():
        setattr(user, field, value)
    
    db.commit()
    db.refresh(user)
    
    return user


def update_user_password(
    db: Session,
    user: models.User,
    new_password: str
) -> models.User:
    """
    更新用户密码
    
    Args:
        db: 数据库会话
        user: 要更新的用户对象
        new_password: 新密码（明文）
        
    Returns:
        更新后的用户对象
    """
    user.hashed_password = hash_password(new_password)
    
    db.commit()
    db.refresh(user)
    
    return user


# ========== 用户删除操作 ==========

def delete_user(db: Session, user_id: int) -> bool:
    """
    删除用户
    
    Args:
        db: 数据库会话
        user_id: 用户 ID
        
    Returns:
        是否删除成功
    """
    user = get_user(db, user_id=user_id)
    if user:
        db.delete(user)
        db.commit()
        return True
    return False


# ========== 用户状态操作 ==========

def activate_user(db: Session, user_id: int) -> Optional[models.User]:
    """
    激活用户
    
    Args:
        db: 数据库会话
        user_id: 用户 ID
        
    Returns:
        激活后的用户对象
    """
    user = get_user(db, user_id=user_id)
    if user:
        user.is_active = True
        db.commit()
        db.refresh(user)
        return user
    return None


def deactivate_user(db: Session, user_id: int) -> Optional[models.User]:
    """
    停用用户
    
    Args:
        db: 数据库会话
        user_id: 用户 ID
        
    Returns:
        停用后的用户对象
    """
    user = get_user(db, user_id=user_id)
    if user:
        user.is_active = False
        db.commit()
        db.refresh(user)
        return user
    return None


